home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 081-090 / amok88 / arexxbox / oberon / test / rxtest2.mod next >
Text File  |  1993-11-04  |  15KB  |  646 lines
  1. (*
  2.  * Source generated with ARexxBox 1.11 (Apr 20 1993)
  3.  * which is Copyright (c) 1992,1993 Michael Balzer
  4.  * Oberon-2 Source by hartmut Goebel 1993
  5.  *)
  6.  
  7. (* $NilChk- $RangeChk- $CaseChk- $OvflChk- $ReturnChk- $ClearVars- *)
  8.  
  9. MODULE RxTest2;
  10.  
  11. (* Dies sind die Basisroutinen der ARexxBox *)
  12.  
  13. IMPORT
  14.   if  := Test2RXIF,  (* die Implementation der Routinen *)
  15.   arb := Test2ARB,   (* das ARB-Modul *)
  16.   BT  := BasicTypes,
  17.   e   := Exec,
  18.   d   := Dos,
  19.   ms  := MoreStrings,
  20.   ol  := OberonLib,
  21.   pf  := Printf,
  22.          RVI,
  23.   rx  := Rexx,
  24.   rxh := ARBRexxHost,
  25.   rxs := RexxSysLib,
  26.   y   := SYSTEM,
  27.   str := Strings;
  28.  
  29. TYPE
  30.   RexxHost * = POINTER TO RexxHostDesc;
  31.   RexxHostDesc * = RECORD (rxh.RexxHostDesc)
  32.   END;
  33.  
  34.   ArgVarStem = UNTRACED POINTER TO STRUCT
  35.     varName: e.STRPTR;
  36.     stemName: e.STRPTR;
  37.   END;
  38.  
  39. CONST
  40.   numCmds = arb.numCmds;
  41.  
  42. TYPE
  43.   CommandListType = ARRAY numCmds OF rxh.Command;
  44.  
  45. CONST
  46.   CommandList = CommandListType(
  47.     y.ADR("ALIAS"), y.ADR("GLOBAL/S,NAME/A,COMMAND/F"), NIL, 0, if.Alias, LONGSET{rxh.enabled},
  48.     y.ADR("CMDSHELL"), y.ADR("OPEN/S,CLOSE/S"), NIL, 0, if.Cmdshell, LONGSET{rxh.enabled},
  49.     y.ADR("DISABLE"), y.ADR("GLOBAL/S,NAMES/M"), NIL, 0, if.Disable, LONGSET{rxh.enabled},
  50.     y.ADR("ENABLE"), y.ADR("GLOBAL/S,NAMES/M"), NIL, 0, if.Enable, LONGSET{rxh.enabled},
  51.     y.ADR("FAULT"), y.ADR("NUMBER/N/A"), y.ADR("DESCRIPTION"), SIZE(rxh.RXD)+1*SIZE(LONGINT), if.Fault, LONGSET{rxh.enabled},
  52.     y.ADR("HELP"), y.ADR("COMMAND,PROMPT/S"), y.ADR("COMMANDDESC,COMMANDLIST/M"), SIZE(rxh.RXD)+2*SIZE(LONGINT), if.Help, LONGSET{rxh.enabled},
  53.     y.ADR("RX"), y.ADR("CONSOLE/S,ASYNC/S,COMMAND/F"), y.ADR("RC/N,RESULT"), SIZE(rxh.RXD)+3*SIZE(LONGINT), if.Rx, LONGSET{rxh.enabled}
  54.     );
  55.  
  56. (*------------- hier beginnt der allgemeine Teil ------------*)
  57.  
  58. PROCEDURE (host: RexxHost) FindCommand * (com: ARRAY OF CHAR): INTEGER;
  59. VAR
  60.   n, pos: INTEGER;
  61.   ug, og, cmp: INTEGER;
  62. BEGIN
  63.   ug := 0; og := numCmds-1;
  64.   n := SHORT(str.Length(com));
  65.   IF n = 0 THEN RETURN -1; END;
  66.  
  67.   str.Upper(com);
  68.  
  69.   (* Init *)
  70.  
  71.   pos := (og + ug) DIV 2;
  72.  
  73.   (* Suchen *)
  74.  
  75.   LOOP
  76.     IF og - ug <= 0 THEN EXIT; END;
  77.  
  78.     cmp := ms.NCStrCmp(com, CommandList[pos].command^);
  79.  
  80.     IF cmp = 0 THEN
  81.       (* gefunden! *)
  82.       EXIT;
  83.     ELSIF cmp < 0 THEN
  84.       (* im linken Zweig weitersuchen *)
  85.       og := pos - 1;
  86.     ELSE
  87.       (* im rechten Zweig weitersuchen *)
  88.       ug := pos + 1;
  89.     END;
  90.  
  91.     pos := (og + ug) DIV 2;
  92.   END;
  93.  
  94.   (* Nachlese *)
  95.   IF cmp # 0 THEN
  96.  
  97.     (* noch nicht gefunden *)
  98.  
  99.     IF ms.NCStrCmp(com, CommandList[pos].command^) = 0 THEN
  100.       RETURN pos;
  101.     ELSIF (ug # og) & (ms.NCStrCmp(com, CommandList[pos+1].command^) = 0) THEN
  102.       RETURN pos+1;
  103.     ELSE
  104.       RETURN -1;
  105.     END;
  106.  
  107.   ELSE
  108.     (* letzter Vergleich war ok *)
  109.     RETURN pos;
  110.   END;
  111. END FindCommand;
  112.  
  113.  
  114. PROCEDURE (host: RexxHost) HandleCommand * (rexxmsg: rx.RexxMsgPtr);
  115. VAR
  116.   com: rxh.CommandPtr;
  117.   rxc: INTEGER;
  118.   argb, argb2: BT.DynString;
  119.   arg: e.STRPTR;
  120.   array: rxh.RXDPtr;
  121.   argVarStem: ArgVarStem;
  122.   resarray: e.APTR;
  123.   rc, rc2: LONGINT;
  124.   cargstr, result: BT.DynString;
  125.   stem, st: rxh.StemNodePtr;
  126.   rm: rx.RexxMsgPtr;
  127. BEGIN
  128.   argb := NIL; cargstr := NIL; result := NIL; array := NIL;
  129.   rc2:=0;
  130.   rc:=20;
  131.  
  132.   LOOP  (* dummy *)
  133.   argb := ms.CopyCStringAdd(rexxmsg.args[0],1);
  134.   IF argb = NIL THEN
  135.     rc2 := rxh.errorNoFreeStore;
  136.     EXIT;
  137.   END;
  138.  
  139.   (* welches Kommando? *)
  140.  
  141.   str.AppendChar(argb^,"\n");
  142.   arg := y.ADR(argb^);
  143.  
  144.   rxc := host.ParseCommand(arg);
  145.  
  146. (* $IF RxAlias *)
  147.   IF rxc = -1 THEN
  148.  
  149.     argb2 := if.ExpandRXCommand(host,rexxmsg.args[0]);
  150.     IF argb2 # NIL THEN
  151.       DISPOSE(argb);
  152.       y.ALLOCATE(argb,str.Length(argb2^)+2);
  153.       IF argb = NIL THEN
  154.         rc2 := rxh.errorNoFreeStore;
  155.         EXIT;
  156.       END;
  157.  
  158.       COPY(argb2^,argb^);
  159.       str.AppendChar(argb^,"\n");
  160.       DISPOSE(argb2);
  161.       arg := y.ADR(argb^);
  162.  
  163.       (* nochmal den Parser mit dem neuen Befehl anwerfen *)
  164.       rxc := ParseRXCommand(arg);
  165.     END;
  166.   END;
  167. (* $END *)
  168.  
  169.   IF rxc = -1 THEN
  170.     (* Msg an ARexx schicken, vielleicht existiert ein Skript *)
  171.  
  172.       rm := host.CreateCommand(rexxmsg.args[0]^, NIL);
  173.       IF rm # NIL THEN
  174.         (* Original-Msg merken *)
  175.         rm.args[15] := y.VAL(e.STRPTR,rexxmsg);
  176.  
  177.         IF host.MsgToRexx(rm) # NIL THEN
  178.           (* Reply wird später vom Dispatcher gemacht *)
  179. (* $IFNOT GarbageCollector *)
  180.             DISPOSE(argb);
  181. (* $END *)
  182.             RETURN;
  183.         ELSE
  184.           rc2 := rxh.errorNotImplemented;
  185.         END;
  186.       ELSE
  187.         rc2 := rxh.errorNoFreeStore;
  188.       END;
  189.     EXIT;
  190.   END;
  191.  
  192.   IF ~(rxh.enabled IN arb.RXCFlags[rxc]) THEN
  193.     rc := -10;
  194.     rc2 := y.ADR(rxh.CommandDisabled);
  195.     EXIT;
  196.   END;
  197.   com := y.ADR(CommandList[rxc]);
  198.  
  199.   (* Speicher für Argumente etc. holen *)
  200.  
  201.   com.function(host, array, rxh.init);
  202.  
  203.   (* Speicher für ReadArgs()-Schablone: 15 Zeichen mehr
  204.    * für Var&Stem (falls Resultate erzeugt werden, s.u.)
  205.    *)
  206.  
  207.   IF com.args # NIL THEN
  208.     cargstr := ms.CopyCStringAdd(com.args,15);
  209.   ELSE
  210.     y.ALLOCATE(cargstr,15);
  211.   END;
  212.  
  213.   IF (array = NIL) OR (cargstr = NIL) THEN
  214.     rc2 := rxh.errorNoFreeStore;
  215.     EXIT;
  216.   END;
  217.  
  218.   (* Adressen der Argumente- und Resultate-Substruktur
  219.    * bestimmen
  220.    *)
  221.  
  222.   argVarStem := y.VAL(y.ADDRESS,y.VAL(LONGINT,array) + SIZE(rxh.RXD));
  223.   resarray := y.VAL(y.ADDRESS,y.VAL(LONGINT,array) + com.resindex);
  224.  
  225.   (* Argumente parsen *)
  226.  
  227.   IF com.results # NIL THEN
  228.     (* Präfix für Resultate: *)
  229.     cargstr^ := "VAR/K,STEM/K";
  230.   ELSE
  231.     cargstr^ := "";
  232.   END;
  233.  
  234.   (* mit dem Argumente-Template zusammensetzen *)
  235.  
  236.   IF  com.args # NIL THEN
  237.     IF cargstr^ # "" THEN
  238.       str.AppendChar(cargstr^, ","); END;
  239.     str.Append(cargstr^, com.args^);
  240.   END;
  241.  
  242.   (* und ReadArgs() darauf loslassen *)
  243.  
  244.   IF cargstr^ # "" THEN
  245.     host.rdargs.source.buffer := y.ADR(arg^);
  246.     host.rdargs.source.length := str.Length(arg^);
  247.     host.rdargs.source.curChr := 0;
  248.     host.rdargs.daList := NIL;
  249.     host.rdargs.buffer := NIL;
  250.  
  251.     IF d.ReadArgs(cargstr^, argVarStem^, host.rdargs) = NIL THEN
  252.       rc := 10;
  253.       rc2 := d.IoErr();
  254.       EXIT;
  255.     END;
  256.   END;
  257.  
  258.   (* Funktion aufrufen *)
  259.   (* Phase 2 (ACTION)! *)
  260.  
  261.   com.function( host, array, rxh.action );
  262.  
  263.   (* Returncodes auslesen *)
  264.  
  265.   rc := array.rc;
  266.   rc2 := array.rc2;
  267.  
  268.   (* Resultat(e) auswerten *)
  269.  
  270.   IF (com.results # NIL) & (rc=0)
  271.     & (rx.rxfResult IN rx.ActionFlags(rexxmsg.action)) THEN
  272.  
  273.     (* Stem-Liste und Variable direkt generieren *)
  274.  
  275.     stem := rxh.CreateSTEM(com, resarray, argVarStem.stemName);
  276.     result := rxh.CreateVAR(stem);
  277.  
  278.     IF stem = NIL THEN
  279.       result := NIL;
  280.       rc := 20;
  281.       rc2 := rxh.errorNoFreeStore;
  282.     ELSIF result # NIL THEN
  283.       (* argarray[0] ist der Name für das VAR-Result *)
  284.       IF argVarStem.varName # NIL THEN
  285.         IF RVI.SetRexxVar(rexxmsg, argVarStem.varName^, result^, str.Length(result^)) = NIL THEN
  286.           rc := -10;
  287.           rc2 := y.ADR(rxh.CantSetVar);
  288.         END;
  289.  
  290. (* $IFNOT GarbageCollector *)
  291.         DISPOSE(result);
  292. (* $ELSE *)
  293.         result := NIL;
  294. (* $END *)
  295.       END;
  296.  
  297.       (* argarray[0] ist der Name für das STEM-Result *)
  298.       IF argVarStem.stemName # NIL THEN
  299.         (* STEM-Liste abarbeiten und setzen *)
  300.         st := stem;
  301.         WHILE st # NIL DO
  302.           rc := rc + RVI.SetRexxVar(rexxmsg,st.name^,st.value^,str.Length(st.value^));
  303.           st := st.succ;
  304.         END;
  305.         (* in rc ist der akkumulierte Fehlercode *)
  306.  
  307.         IF rc # 0 THEN
  308.           rc := -10;
  309.           rc2 := y.ADR(rxh.CantSetVar);
  310.         END;
  311.  
  312. (* $IFNOT GarbageCollector *)
  313.         DISPOSE(result);
  314. (* $ELSE *)
  315.         result := NIL;
  316. (* $END *)
  317.       END;
  318.     END;
  319.  
  320.     rxh.FreeStemList(stem);
  321.   END;
  322.   EXIT;
  323.   END; (* dummyLoop *)
  324.  
  325.   (* Nur RESULT, wenn weder VAR noch STEM *)
  326.  
  327.   host.ReplyMsg(rexxmsg, rc, rc2, result);
  328.  
  329.   (* benutzten Speicher freigeben *)
  330. (* $IFNOT GarbageCollector *)
  331.   DISPOSE(result);
  332. (* $ELSE *)
  333.   result := NIL;
  334. (* $END *)
  335.   d.FreeArgs(host.rdargs);
  336.   IF (array # NIL) THEN com.function(host,array, rxh.free); END;
  337. (* $IFNOT GarbageCollector *)
  338.   DISPOSE(cargstr);
  339.   DISPOSE(argb);
  340. (* $END *)
  341. END HandleCommand;
  342.  
  343.  
  344. PROCEDURE (host: RexxHost) HandleShellCommand * (comline: ARRAY OF CHAR;
  345.                                                    fhout: d.FileHandlePtr);
  346. VAR
  347.   com: rxh.CommandPtr;
  348.   rxc: INTEGER;
  349.   argb, argb2: BT.DynString;
  350.   arg: e.STRPTR;
  351.   array: rxh.RXDPtr;
  352.   argVarStem: ArgVarStem;
  353.   resarray: e.APTR;
  354.   rc, rc2: LONGINT;
  355.   cargstr, result: BT.DynString;
  356.   sentrm, rm: rx.RexxMsgPtr;
  357.   waiting: BOOLEAN;
  358.   stem, st: rxh.StemNodePtr;
  359. BEGIN
  360.   argb := NIL; cargstr := NIL; array := NIL;
  361.   rc2:=0; rc:=20;
  362.  
  363.   LOOP  (* dummy *)
  364.   y.ALLOCATE(argb,str.Length(comline)+2);
  365.   IF argb = NIL THEN
  366.     rc2 := rxh.errorNoFreeStore;
  367.     EXIT;
  368.   END;
  369.  
  370.   (* welches Kommando? *)
  371.   COPY(comline,argb^);
  372.   str.AppendChar(argb^,"\n");
  373.   arg := y.ADR(argb^);
  374.  
  375.   rxc := host.ParseCommand(arg);
  376.  
  377. (* $IF RxAlias *)
  378.   IF rxc = -1 THEN
  379.  
  380.     argb2 := if.ExpandRXCommand(host,comline);
  381.     IF argb2 # NIL THEN
  382.       DISPOSE(argb);
  383.       y.ALLOCATE(argb,str.Length(argb2^)+2);
  384.       IF argb = NIL THEN
  385.         rc2 := rxh.errorNoFreeStore;
  386.         EXIT;
  387.       END;
  388.  
  389.       COPY(argb2^,argb^);
  390.       str.AppendChar(argb^,"\n");
  391.       DISPOSE(argb2);
  392.       arg := y.ADR(argb^);
  393.  
  394.       rxc := ParseRXCommand(arg);
  395.     END;
  396.   END;
  397. (* $END *)
  398.  
  399.   IF rxc = -1 THEN
  400.  
  401.     sentrm := host.SendCommand(comline,NIL);
  402.     IF sentrm # NIL THEN
  403.       (* auf Reply warten *)
  404.       waiting := TRUE;
  405.       REPEAT
  406.         e.WaitPort(host.port);
  407.         LOOP
  408.           rm := e.GetMsg(host.port);
  409.           IF rm = NIL THEN EXIT; END;
  410.  
  411.           (* Reply *)
  412.           IF rm.node.node.type = e.replyMsg THEN
  413.  
  414.             (* zu diesem Kommando *)
  415.             IF rm = sentrm THEN
  416.               IF rm.result1 # 0 THEN
  417.                 rc := 20;
  418.                 rc2 := rxh.errorNotImplemented;
  419.               ELSE
  420.                 rc := 0; rc2 := 0;
  421.                 IF rm.result2 # 0 THEN
  422.                   IF d.FPrintf(fhout,"%s\n",rm.result2) = 0 THEN END;
  423.                 END;
  424.               END;
  425.               waiting  := FALSE;
  426.             END;
  427.             host.FreeCommand(rm);
  428.             DEC(host.replies);
  429.  
  430.           ELSE
  431.             host.ReplyMsg(rm,-20,y.ADR("CommandShell Port"),NIL);
  432.           END;
  433.  
  434.         END;
  435.       UNTIL ~ waiting;
  436.     ELSE
  437.       rc2 := rxh.errorNoFreeStore;
  438.       EXIT;
  439.     END;
  440.   END;
  441.  
  442.   IF ~(rxh.enabled IN arb.RXCFlags[rxc]) THEN
  443.     rc := -10;
  444.     rc2 := y.ADR(rxh.CommandDisabled);
  445.     EXIT;
  446.   END;
  447.   com := y.ADR(CommandList[rxc]);
  448.  
  449.   (* Speicher für Argumente etc. holen *)
  450.  
  451.   com.function(host, array, rxh.init );
  452.   IF com.args # NIL THEN
  453.     cargstr := ms.CopyCStringAdd(com.args,512);
  454.   ELSE
  455.     y.ALLOCATE(cargstr,512);
  456.   END;
  457.  
  458.   IF (array = NIL) OR (cargstr = NIL) THEN
  459.     rc2 := rxh.errorNoFreeStore;
  460.     EXIT;
  461.   END;
  462.  
  463.   argVarStem := y.VAL(y.ADDRESS,y.VAL(LONGINT,array) + SIZE(rxh.RXD));
  464.   resarray := y.VAL(y.ADDRESS,y.VAL(LONGINT,array) + com.resindex);
  465.  
  466.   (* Argumente parsen *)
  467.  
  468.   IF com.results # NIL THEN
  469.     (* Präfix für Resultate: *)
  470.     cargstr^ := "VAR/K,STEM/K";
  471.   ELSE
  472.     cargstr^ := "";
  473.   END;
  474.  
  475.   (* mit dem Argumente-Template zusammensetzen *)
  476.  
  477.   IF  com.args # NIL THEN
  478.     IF cargstr^ # "" THEN
  479.       str.AppendChar(cargstr^, ","); END;
  480.     str.Append(cargstr^, com.args^);
  481.   END;
  482.  
  483.   (* und ReadArgs() darauf loslassen *)
  484.  
  485.   IF cargstr^ # "" THEN
  486.     host. rdargs.source.buffer := y.ADR(arg^);
  487.     host.rdargs.source.length := str.Length(arg^);
  488.     host.rdargs.source.curChr := 0;
  489.     host.rdargs.daList := NIL;
  490.     host.rdargs.buffer := NIL;
  491.     host.rdargs.flags := LONGSET{d.noPrompt};
  492.  
  493.     IF d.ReadArgs(cargstr^, argVarStem^, host.rdargs) = NIL THEN
  494.       rc := 10;
  495.       rc2 := d.IoErr();
  496.       EXIT;
  497.     END;
  498.   END;
  499.  
  500.   (* Funktion aufrufen *)
  501.  
  502.   com.function( host,array, rxh.action );
  503.  
  504.   (* Resultat(e) ausgeben *)
  505.  
  506.   IF (com.results # NIL) & (argVarStem.varName # NIL)
  507.     & (fhout # NIL) THEN
  508.  
  509.     stem := rxh.CreateSTEM(com, resarray, argVarStem.stemName);
  510.     result := rxh.CreateVAR(stem);
  511.  
  512.     IF result # NIL THEN (* Variablenwerte nun hier direkt auf die Console
  513.                           * ausgeben, statt SetRexxVar() *)
  514.       IF argVarStem.varName # NIL THEN
  515.         IF stem = NIL THEN      (* VAR *)
  516.           rc2 := rxh.errorNoFreeStore;
  517.           EXIT;
  518.         END;
  519.         IF d.FPrintf(fhout,"%s = %s\n",argVarStem.varName,y.ADR(result^)) = 0 THEN END;
  520. (* $IFNOT GarbageCollector *)
  521.         DISPOSE(result);
  522. (* $ELSE *)
  523.         result := NIL;
  524. (* $END *)
  525.       END;
  526.  
  527.       IF argVarStem.stemName # NIL THEN
  528.         IF stem = NIL THEN
  529.           rc2 := rxh.errorNoFreeStore;
  530.           EXIT;
  531.         END;
  532.  
  533.         st := stem;
  534.         WHILE st # NIL DO
  535.           IF d.FPrintf(fhout,"%s = %s\n",y.ADR(st.name^),y.ADR(st.value^)) = 0 THEN END;
  536.         END;
  537. (* $IFNOT GarbageCollector *)
  538.         DISPOSE(result);
  539. (* $ELSE *)
  540.         result := NIL;
  541. (* $END *)
  542.       END;
  543.     END;
  544.  
  545.     rxh.FreeStemList(stem);
  546.   END;
  547.  
  548.   (* Nur RESULT, wenn weder VAR noch STEM *)
  549.   IF result # NIL THEN
  550.     IF stem = NIL THEN
  551.       rc2 := rxh.errorNoFreeStore;
  552.       EXIT;
  553.     ELSE
  554.       IF d.FPrintf( fhout, "%s\n", y.ADR(result^) ) = 0 THEN END;
  555. (* $IFNOT GarbageCollector *)
  556.       DISPOSE(result);
  557. (* $ELSE *)
  558.       result := NIL;
  559. (* $END *)
  560.     END;
  561.   END;
  562.  
  563.   rc  := array.rc;
  564.   rc2 := array.rc2;
  565.  
  566.   EXIT;
  567.   END; (* dummyLoop *)
  568.  
  569.   arg := NIL;
  570.  
  571.   (* Fehler ebenfalls direkt in lesbarer Form in die
  572.    * Ausgabedatei drucken
  573.    *)
  574.  
  575.   IF rc2 # 0 THEN
  576.     IF cargstr = NIL THEN y.ALLOCATE(cargstr,512); END;
  577.  
  578.     IF cargstr = NIL THEN
  579.       arg := y.ADR("ERROR: Absolutely out of memory");
  580.     ELSIF rc > 0 THEN
  581.       IF d.Fault( rc2, "ERROR", cargstr^, 512 ) THEN
  582.         arg := y.ADR(cargstr^);
  583.       ELSE
  584.         arg := y.ADR("ERROR: Unknown Problem");
  585.       END;
  586.     ELSIF rc < 0 THEN
  587.       cargstr^ := "ERROR: ";
  588.       str.Append(cargstr^,y.VAL(e.STRPTR,rc2)^);
  589.       arg := y.ADR(cargstr^);
  590.     END;
  591.   END;
  592.  
  593.   IF (arg # NIL) & (d.FPrintf( fhout, "%s\n", arg ) = 0) THEN END;
  594.  
  595.   (* benutzten Speicher freigeben *)
  596.  
  597.   d.FreeArgs(host.rdargs);
  598.   IF (array # NIL) THEN com.function(host,array, rxh.free); END;
  599. (* $IFNOT GarbageCollector *)
  600.   DISPOSE(cargstr);
  601.   DISPOSE(argb);
  602. (* $END *)
  603. END HandleShellCommand;
  604.  
  605.  
  606. PROCEDURE SetupARexxHost * (basename: e.STRPTR): RexxHost;
  607. VAR
  608.   rh: RexxHost;
  609. BEGIN
  610.   NEW(rh);
  611.   IF rh # NIL THEN
  612.     IF ~ rxh.Init(rh,basename,arb.defaultName,arb.extension) THEN
  613.      (* $IFNOT GarbageCollector *)
  614.        DISPOSE(rh);
  615.      (* $END *)
  616.      rh := NIL;
  617.     END;
  618.   END;
  619.   RETURN rh;
  620. END SetupARexxHost;
  621.  
  622. PROCEDURE CloseDownARexxHost * (VAR rh: RexxHost);
  623. BEGIN
  624.   rh.Uninit;
  625.   (* $IFNOT GarbageCollector *)
  626.     DISPOSE(rh);
  627.   (* $END *)
  628.   rh := NIL;
  629. END CloseDownARexxHost;
  630.  
  631.  
  632. PROCEDURE InitFlags;
  633. VAR
  634.   i: INTEGER;
  635. BEGIN
  636.   i := numCmds;
  637.   REPEAT
  638.     DEC(i); arb.RXCFlags[i] := CommandList[i].flags;
  639.   UNTIL i = 0;
  640. END InitFlags;
  641.  
  642. BEGIN
  643.   InitFlags;
  644.  
  645. END RxTest2.
  646.